home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / mus / misc / MPTool.lha / MPTool / MPTool.c < prev    next >
C/C++ Source or Header  |  1998-04-07  |  14KB  |  498 lines
  1.  /* MPTool   -  First Step : 04/09/97
  2.                 Last Modif : 02/04/98
  3.          by HEINRICH Patrick
  4.     Nothing but a working version ;)
  5.     Frozen : V0.04                    */
  6.  
  7.  
  8. #include        <stdio.h>
  9. #include        <string.h>
  10. #include        <stdlib.h>
  11. #include        <dos/dos.h>
  12.  
  13. #define         VER     "0.04"
  14. #define         MESS1   " Usage : %s <Option> <Files |Dirs | Volumes>"
  15. #define         OPT1    "  <Option> :    a  <=>  simple time listing and automatically cut wave header\n"
  16. #define         OPT2    "                c  <=>  simple time listing and add duration/kbps in comment\n"
  17. #define         OPT3    "                t  <=>  simple time listing (don't modify your comments)\n"
  18. #define         OPT4    "                w  <=>  cut the wave header of a given file\n\n"
  19. #define         RET     printf("\n")
  20.  
  21.  
  22. /* ========================================================================================= */
  23.  
  24.     FILE   *infp;
  25.     char   *ptr;
  26.     char   path [256];
  27.     long   filesize=0;
  28.     long   mpduration=0;
  29.     long   mptotsize=0;
  30.     int    filetot=0;
  31.     int    dirtot=0;
  32.     int    mptot=0;
  33.     int    wavetot=0;
  34.     int    com=0;
  35.     int    count=2;
  36.     int    automatic=0;
  37.     struct FileInfoBlock *fib3_ptr;
  38.     struct FileLock *File3Lock ;
  39.  
  40.     struct FileHandle *InFile;
  41.     struct FileHandle *OutFile;
  42.     long bytes_read;
  43.     long buffersize=4096;
  44.     char * tempo=NULL;
  45.  
  46. /* ========================================================================================= */
  47.  
  48.     void ExamineIt(char* File2Lock);
  49.     void IsMPEG(char* gimmefile,long zisize);
  50.  
  51. /* ========================================================================================= */
  52.  
  53. main(int argc, char *argv[])
  54.  
  55. {
  56.     printf("\n%c[1;31m MPTool %c[0mV%s '98 by %c[1;32m·HEINRICH Patrick·%c[0m \n",27,27,VER,27,27);
  57.     printf("\n Registered to : %c[0;33mEverybody%c[0m \n\n",27,27);
  58.  
  59.     if (argc < 3) { printf(MESS1,argv[0]);RET;RET;
  60.                     printf(OPT1);printf(OPT2);printf(OPT3);printf(OPT4);exit(0); }
  61.  
  62.     switch (*argv[1])
  63.  
  64.     {
  65.  
  66.     case 'w':case'W':
  67.  
  68.  
  69.     InFile=(struct FileHandle *) Open(argv[2],MODE_OLDFILE);
  70.  
  71.     tempo=calloc(buffersize,sizeof(char));
  72.  
  73.  
  74.     Read(InFile, tempo, 5);
  75.     tempo[4]=NULL;
  76.  
  77.     if ( (strcmp("RIFF",tempo))!=0 ) {
  78.                                       printf(" File %s has no wave header ! \n\n",argv[2]);
  79.                                       Close(InFile);
  80.                                       exit(0);
  81.                                      }
  82.  
  83.  
  84.     if (argc==4) { OutFile=(struct FileHandle *) Open(argv[3],MODE_NEWFILE); }
  85.     else         { strcpy(path,argv[2]);
  86.                    path[(strlen(argv[2])-1)]=-57;
  87.                    OutFile=(struct FileHandle *) Open(path,MODE_NEWFILE);
  88.                  }
  89.     Seek(InFile,70,OFFSET_BEGINNING);
  90.  
  91.     printf(" Trying to cut the wave header of %s ...\n",argv[2]);
  92.  
  93.     while ((bytes_read=Read(InFile, tempo, buffersize))==buffersize)
  94.  
  95.     {
  96.     Write(OutFile, tempo, buffersize);
  97.     }
  98.  
  99.     Write(OutFile, tempo, bytes_read);
  100.  
  101.  
  102.     free(tempo);
  103.     Close(InFile);
  104.     Close(OutFile);
  105.  
  106.     if (argc==3) {remove(argv[2]);rename(path,argv[2]);}
  107.  
  108.     printf(" %s has been successfully dewaved !\n\n",argv[2]);
  109.  
  110.     exit(0);
  111.  
  112.     case 'c':case'C':
  113.  
  114.     com=1;
  115.  
  116.     case 't':case'T':
  117.  
  118.     ReadyGo:
  119.  
  120.     /* is argv[count] a directory/file/volume */
  121.  
  122.     for ( count=2; (count<=(argc-1)) ;count++ )
  123.  
  124.     {
  125.  
  126.     JumpIn:
  127.  
  128.     strcpy(path,argv[count]);
  129.     ptr=path;
  130.     while ((*ptr!=':') && (*ptr!=0)) {ptr++;} ptr++;
  131.     if (*ptr!=0)
  132.                     {
  133.                     while (*ptr!=0) {ptr++;}
  134.                     ptr--;
  135.                     if (*ptr!='/') {} else {*ptr=0;}
  136.                     }
  137.  
  138.     fib3_ptr = AllocMem( sizeof( struct FileInfoBlock ),0 );
  139.  
  140.     File3Lock = Lock( path, -2 );
  141.     if ( File3Lock  == NULL ) {printf("\n Can't lock file %s\n",File3Lock);}
  142.  
  143.     Examine(File3Lock,fib3_ptr);
  144.  
  145.     if ((*fib3_ptr).fib_DirEntryType<0)
  146.             {
  147.             filesize=(*fib3_ptr).fib_Size;
  148.             IsMPEG(argv[count],filesize);
  149.             UnLock(File3Lock);
  150.             FreeMem( fib3_ptr, sizeof( struct FileInfoBlock ) );
  151.             count++;
  152.             filetot++;
  153.             if (count<=argc-1) goto JumpIn;
  154.             goto EndPart;
  155.             }
  156.  
  157.  
  158.     UnLock(File3Lock);
  159.     FreeMem( fib3_ptr, sizeof( struct FileInfoBlock ) );
  160.  
  161.  
  162.     if (argc==3)
  163.  
  164.         {
  165.         printf("\n============================[MPTool]===['98·TMG·]===============================\n\n");
  166.         printf("    MPTool was started from %s\n",path);
  167.         }
  168.         printf("\n============================[MPTool]===['98·TMG·]===============================\n\n");
  169.  
  170.  
  171.     ExamineIt(path);
  172.     }
  173.  
  174.     EndPart:
  175.  
  176.     printf("\n============================[MPTool]===['98·TMG·]===============================\n");
  177.     if (argc==3) printf("\n %s \n",path);
  178.     printf("\n                         %12i MPEG Files (MPEG or WAVE header)\n",mptot);
  179.     printf("                         %12i Files\n",filetot);
  180.     printf("                         %12i Directories\n",dirtot);
  181.     printf("                         %12i MPEG Files with a WAVE header\n",wavetot);
  182.     if (mptotsize/(1024*1024) >= 2)
  183.     printf("\n                         %12d Mbs of MPEG\n",mptotsize/(1024*1024));
  184.     printf("                         %12d Kbs of MPEG\n",mptotsize/1024);
  185.     printf("                         %12d bytes of MPEG\n",mptotsize);
  186.     printf("\n                             %02i:%02i:%02i Total Duration of the listed files\n",(mpduration/3600),((mpduration-3600*(mpduration/3600))/60),mpduration-3600*(mpduration/3600)-60*((mpduration-3600*(mpduration/3600))/60));
  187.     printf("\n============================[MPTool]===['98·TMG·]===============================\n\n");
  188.  
  189.     break;
  190.  
  191.     case 'a':case 'A':
  192.  
  193.     automatic=1;
  194.     goto ReadyGo;
  195.  
  196.  
  197.     default:
  198.  
  199.     RET;printf(MESS1,argv[0]);RET;RET;printf(OPT1);printf(OPT2);
  200.         printf(OPT3);printf(OPT4);exit(0);
  201.  
  202.  
  203.     }
  204.  
  205.  
  206. }
  207.  
  208. /* ========================================================================================= */
  209.  
  210. void ExamineIt(char* File2Lock)
  211.  
  212.     {
  213.     int count=0;            /* check 4 dir */
  214.     int fromvol=1;          /* check for a lone volume */
  215.     long size=0;
  216.     char newpath [256];
  217.     char newpass [256];
  218.     char* carptr;
  219.     struct FileInfoBlock *fib_ptr;
  220.     struct FileLock *File1Lock ;
  221.  
  222.  
  223.     fib_ptr = AllocMem( sizeof( struct FileInfoBlock ),0 );
  224.  
  225.     strcpy(newpath,File2Lock);
  226.     carptr=newpath;
  227.  
  228.     while (*carptr!=':') {carptr++;} carptr++;
  229.     if (*carptr!=0) {fromvol=0;}
  230.  
  231.     if( fib_ptr == NULL ) { printf("\n Not Enough Memory \n");exit(0); }
  232.  
  233.     File1Lock = Lock( File2Lock, -2 );
  234.     if ( File1Lock  == NULL ) {printf("\n Can't lock file %s\n",File2Lock);}
  235.  
  236.     Examine(File1Lock,fib_ptr);
  237.  
  238.     while (ExNext(File1Lock,fib_ptr))
  239.  
  240.         {
  241.         if ( ((*fib_ptr).fib_DirEntryType>0) && (fib_ptr!=NULL) )
  242.              {
  243.                dirtot++;
  244.                if (count!=0)
  245.                     {
  246.                     if (fromvol==1)
  247.                         {
  248.                         strcpy(newpath,File2Lock);
  249.                         strcat(newpath,(*fib_ptr).fib_FileName);
  250.                         }
  251.                     else
  252.                         {
  253.                         strcpy(newpath,File2Lock);strcat(newpath,"/");
  254.                         strcat(newpath,(*fib_ptr).fib_FileName);
  255.                         }
  256.                     }
  257.                else
  258.                     {
  259.                     if (fromvol==1)
  260.                         {
  261.                         strcat(newpath,(*fib_ptr).fib_FileName);
  262.                         }
  263.                     else
  264.                         {
  265.                         strcat(newpath,"/");
  266.                         strcat(newpath,(*fib_ptr).fib_FileName);
  267.                         }
  268.                     }
  269.                ExamineIt(newpath);
  270.                count++;
  271.              }
  272.  
  273.  
  274.         else {
  275.                filetot++;
  276.                size=(*fib_ptr).fib_Size;
  277.                strcpy(newpass,File2Lock);
  278.                if (fromvol==1)
  279.                     {
  280.                     IsMPEG(strcat(newpass,(*fib_ptr).fib_FileName),size);
  281.                     }
  282.                else
  283.                     {
  284.                     strcat(newpass,"/");
  285.                     IsMPEG(strcat(newpass,(*fib_ptr).fib_FileName),size);
  286.                     }
  287.              }
  288.         }
  289.     UnLock(File1Lock);
  290.     FreeMem( fib_ptr, sizeof( struct FileInfoBlock ) );
  291.     }
  292.  
  293. /* ========================================================================================= */
  294.  
  295. void IsMPEG(char* gimmefile,long zisize)
  296.  
  297.     {
  298.     int           kbps=0;
  299.     int           wave=0;
  300.     int           buffersize=4096;
  301.     struct        FileHandle * InFile;
  302.     struct        FileHandle * OutFile;
  303.     char          path [256];
  304.     char          commy [80];
  305.     char          temp [10];
  306.     char *        tempo;
  307.     long          tmpsize;
  308.     long          bytes_read;
  309.     unsigned char Buffer [10];           // buffer to store some infos from infile
  310.  
  311.     tmpsize=zisize;
  312.     InFile=(struct FileHandle *) Open(gimmefile,MODE_OLDFILE);
  313.  
  314.     Read(InFile,Buffer,10);              // reads the header of the file
  315.  
  316.     Buffer[4]=NULL;
  317.     
  318.     if ( (strcmp("RIFF",Buffer))==0 )    // if there is a WAVE header
  319.       {
  320.        Seek(InFile,70,OFFSET_BEGINNING);
  321.        Read(InFile,Buffer,10);           // reads the real header of the file
  322.        wavetot++;
  323.        wave=1;
  324.       }
  325.  
  326.     if ( Buffer[0]!=255 )
  327.  
  328.         {
  329.         Close(InFile); return;
  330.         }
  331.  
  332.  
  333.     if (!( (Buffer[1]==251) || (Buffer[1] == 242) || (Buffer[1] == 250) || (Buffer[1] == 252)))
  334.  
  335.         {
  336.         Close(InFile); return;
  337.         }
  338.  
  339.  
  340.     if ((Buffer[1]==250) || (Buffer[1]==251))
  341.  
  342.       { 
  343.         switch (Buffer[2])
  344.  
  345.         {
  346.  
  347.         case 16:    kbps=32;break;
  348.         case 32:    kbps=40;break;
  349.         case 48:    kbps=48;break;
  350.         case 64:    kbps=56;break;
  351.         case 80:    kbps=64;break;
  352.         case 96:    kbps=80;break;
  353.         case 112:   kbps=96;break;
  354.         case 128:   kbps=112;break;
  355.         case 144:   kbps=128;break;
  356.         case 160:   kbps=160;break;
  357.         case 176:   kbps=192;break;
  358.         case 192:   kbps=224;break;
  359.         case 208:   kbps=256;break;
  360.         case 224:   kbps=320;break;
  361.  
  362.         default: kbps=128;break;
  363.         }
  364.       }
  365.  
  366.      else
  367.  
  368.       {
  369.  
  370.         if (Buffer[1]==252)
  371.  
  372.             {
  373.  
  374.             switch (Buffer[2])
  375.  
  376.             {
  377.  
  378.             case 16:    kbps=32;break;
  379.             case 32:    kbps=48;break;
  380.             case 48:    kbps=56;break;
  381.             case 64:    kbps=64;break;
  382.             case 80:    kbps=80;break;
  383.             case 96:    kbps=96;break;
  384.             case 112:   kbps=112;break;
  385.             case 128:   kbps=128;break;
  386.             case 144:   kbps=168;break;
  387.             case 160:   kbps=192;break;
  388.             case 176:   kbps=224;break;
  389.             case 192:   kbps=256;break;
  390.             case 208:   kbps=320;break;
  391.             case 224:   kbps=384;break;
  392.  
  393.             default: Close(InFile); return;
  394.             }
  395.             }
  396.          else {
  397.                 if (Buffer[1]==242)
  398.  
  399.                     {
  400.  
  401.                     switch (Buffer[2])
  402.  
  403.                     {
  404.  
  405.                     case 16:    kbps=8;break;
  406.                     case 32:    kbps=16;break;
  407.                     case 48:    kbps=24;break;
  408.                     case 64:    kbps=32;break;
  409.                     case 80:    kbps=40;break;
  410.                     case 96:    kbps=48;break;
  411.                     case 112:   kbps=56;break;
  412.                     case 128:   kbps=64;break;
  413.                     case 144:   kbps=80;break;
  414.                     case 160:   kbps=96;break;
  415.                     case 176:   kbps=112;break;
  416.                     case 192:   kbps=128;break;
  417.                     case 208:   kbps=144;break;
  418.  
  419.                     default:Close(InFile); return;
  420.                     }
  421.                     }
  422.                  else {Close(InFile); return;}
  423.                }
  424.  
  425.       }
  426.  
  427.     if ( (wave==1) && (automatic==1) )
  428.         {
  429.         printf(" cutting the wave header of file %s\n",gimmefile);
  430.         strcpy(path,gimmefile);
  431.         path[(strlen(gimmefile)-1)]=-57;
  432.         OutFile=(struct FileHandle *) Open(path,MODE_NEWFILE);
  433.         Seek(InFile,70,OFFSET_BEGINNING);
  434.  
  435.         tempo=calloc(buffersize,sizeof(char));
  436.  
  437.  
  438.         while ((bytes_read=Read(InFile, tempo, buffersize))==buffersize)
  439.                  {
  440.                  Write(OutFile, tempo, buffersize);
  441.                  }
  442.  
  443.         Write(OutFile, tempo, bytes_read);
  444.         free(tempo);
  445.         Close(InFile);
  446.         Close(OutFile);
  447.         remove(gimmefile);
  448.         rename(path,gimmefile);
  449.         }
  450.  
  451.     else
  452.  
  453.         {
  454.         Close(InFile);
  455.         }
  456.  
  457.     mpduration=mpduration+(8*zisize/1000/kbps);
  458.     printf(" %-65.65s %0.2ld:%0.2ld %3ikbps\n",gimmefile,(8*zisize/1000/kbps/60),(8*zisize/1000/kbps)-(8*zisize/1000/kbps/60)*60,kbps);
  459.  
  460.         if (com==1)
  461.            {
  462.            if ((8*zisize/1000/kbps/60)<10) {strcpy(commy," [0");} else {strcpy(commy," [");}
  463.  
  464.            stci_d(temp,(8*zisize/1000/kbps/60));
  465.            strcat(commy,temp);
  466.            strcat(commy,":");
  467.  
  468.            zisize=((8*zisize/1000/kbps)-(8*zisize/1000/kbps/60)*60);
  469.  
  470.            if ( zisize <10 ) {strcat(commy,"0");}
  471.  
  472.            stci_d(temp,zisize);
  473.            strcat(commy,temp);
  474.            strcat(commy,"] - [");
  475.            stci_d(temp,kbps);
  476.            strcat(commy,temp);
  477.            strcat(commy,"kbps]");
  478.  
  479.            SetComment(gimmefile , commy);
  480.            }
  481.  
  482.     mptot++;
  483.     mptotsize=mptotsize+tmpsize;
  484.     }
  485.  
  486. /* ========================================================================================= */
  487.  
  488.  
  489.  
  490.  
  491. /* ========================================================================================= */
  492. /*                                      THE END                                              */
  493. /* ========================================================================================= */
  494.  
  495.  
  496.  
  497.  
  498.